The compiler team has placed heavy emphasis on code generation for this release. You will find that the code generation has improved significantly over the 6.0.1 compiler. We have improved our internal testing strategy for the compiler which has greatly improved the overall quality. We have succeeded in removing all of the known code generation problems. If you encounter a suspected code generation problem with the compiler, do not assume that we know about it already. Please send any and all problems via Applelink to THINK.BUGS, or call our technical support hotline.
Compiler Release Highlights
==================
1. All of the reported multiple inheritance code generation problems have been fixed.
2. The code generation has been significantly improved, and all known code generation bugs have been fixed.
3. Pascal object support has been improved, and numerous problems with pascal object support have been addressed. Specifically:
• Pascal object now calls constructors and destructors correctly up the inheritance chain.
• Pascal object classes can now contain non pascal object structures inside them, the code generation problems with this have been fixed.
4. Numerous front-end problems have been fixed, and the process of moving towards the emerging ANSI C++ draft standard has begun.
5. The compiler now merges constant strings together within a translation unit. For example, each use of __FILE__ will share the same string storage. This will reduce the amount of data overhead required when using the assert() macro.
6. The maximum size of a mangled name has been increased from 256 characters to 1024 characters. This should allieviate problems using the Booch components and other programs with deeply nested template constructs.
Important Release Notes
======================
1. If your project type is a code resource virtual functions cannot be used. The data-to-code relocations which are used for other project types are not safe because the code segment can be moved between invocations of the code resource. This is a restriction on code resources and is not considered a bug.
2. If your project type is a code resource, static constructors are not called. This is because it is impossible for the run-time library to determine when the program is starting to execute. Work around this by constructing objects explicitly.
3. Template classes that contain virtual functions must be expanded using the #pragma template directives outlined in the documentation. This is because the compiler will generate the virtual tables globally even though the other class information is static. For example:
x.h:
#pragma template_access extern // Required because class X has virtual functions
template <class T> class X {
T t;
virtual void f(void);
};
x.c:
#include "x.h"
#pragma template_access public // Do this in only 1 translation unit
template <class T> void X<T>::f(void)
{
t++;
}
#pragma template X<int> // instantiate global X<int>
#pragma template X<short> // instantiate global X<short>
If you do not do this explicit expansion, you will get multiply-defined virtual function tables in every translation unit that contains the same expansion of template class X.
4. Unreferenced static objects. When using the compiler, if a reference is not made to some function from a given translation unit, that unit is not included in the built object. This means that static constructors from that translation unit are not called. To work around this problem, insure that all files that contain static constructors have at least one function which is actually called. This behavior is correct as per the ARM.
5. When overriding operator new and/or operator delete, use the 'CplusLib TCL' library in order to avoid multiply-defined errors for operator new and operator delete at link time.
6. In general, the option settings used when precompiling a header should be the same settings used during the compilation. Specifically, when using the 68881 code generation option, several system includes depend on this setting and actually compile differently. If you are compiling for 68881 code generation, make sure you re-precompile any precompiled headers prior to building your application. This problem is most noticeable for setjmp.h, which saves and restores the FPU registers if 68881 code generation is turned on.
New Error and Warning Messages
=============================
The following error messages were added too late to make it into the documentation:
1. type or storage class is required in the declaration of '<identifier>'
This error message is received when a type name has not been declared properly and an attempt is made to declare a variable of that type. For example:
ABC abc; // If ABC is not declared as a type, you receive the above error message
This error is also received when an attempt is made to declare an identifier without a type
or storage class. For example:
j; // Attempt to declare j as an int will receive error message.
2. Function definitions with seperate parameter lists are obsolete in C++
This error message is a warning when not using ANSI mode, but becomes an error when ANSI mode is turned on. It indicates that you are using an old-style C declaration for a function. For example:
void f(int, int, char *);
void f( a, b, c ) // Error
int a;
int b;
char *c;
{
}
3. Casting from incomplete structure type <identifier>
This warning message indicates that an attempt was made to cast from an incomplete structure type. This can cause problems if this class is later declared in a multiple inheritance relationship with the destination type. Such a cast could require modification of the pointer's value. When working with forward-declared classes, the compiler must assume that no modification is required. For example:
file1.c:
struct A *p;
struct B *p2;
p = (A *) p2; // Warning
file2.c:
struct A { };
struct B : public virtual A { };
This program might crash at run-time because the cast in file1.c will not change the pointer correctly. This cast could be avoided altogether because if the types are complete, you can implicitly convert from a B * into an A *.
4. Illegal use of template type arugment during expansion of template <identifier>
This error is received when attempting to use a template argument after the class name in the declaration of the class, or after the constructor or destructor declaration. For example:
template <class T> class X<T> { }; // Error, do not use <T> after the class name X
5. Maximum number of 10 nested template expansions exceeded for expansion of '<identifier>'
This error is received when attempting to nest template expansions beyond 10 levels. It normally occurs when an infinite template expansion is detected.
Manual Errata
============
The 'Warning Messages' page of the C++ compiler options dialog on p. 106 of the compiler guide was updated after the documentation was complete. The screen shot below is the current composition of this dialog box:
The two options not covered in the documentation are:
1. 'Old style function definitions' - This option controls whether old C style function definitions produce a warning. If the ANSI switch is on, this warning becomes an error and cannot be disabled. For example:
void f(a) // Warning: Function definitions with seperate parameter lists are
// obsolete in C++
int a;
{
}
2. 'Cast from incomplete type' - This option controls whether a warning message is produced when a cast is made from a pointer to an incomplete structure type to a pointer to another structure type. This can cause problems if this class is later declared in a multiple inheritance relationship because the cast could change the value of the pointer. Whenever a cast is made from a structure type to another structure type, both types should be complete in order to guarantee correct code generation. For example:
